Validate sampleRate in GetTotalLatencySamples itself rather than relying on
the indirect throw via GetLatencySamples, so an override that folds the
upstream recursion before delegating still honors the contract. Cover the
aggregating entry point in the non-positive-rate test.

Addresses Copilot review feedback on PR #1998.

Claude-Session: https://claude.ai/code/session_01PJ9eDL52jpiM1t5oDRCLM2

Recovers the clip-tail audio that a lookahead effect (the Limiter) leaves
stuck in its delay line. Adds AudioNode.Flush(context): a node drains the
latency it still holds, treating the upstream source as exhausted (a leaf
returns silence), so a trimmed clip never bleeds real audio. The default
passes a single input's drain through unchanged; LimiterNode overrides it to
push its lookahead delay line out through the same path Process uses.

ClipNode, on the window that reaches the clip's true end, calls
Inputs[0].Flush over the clip-local range [Duration, Duration+L) — contiguous
with the main slice, so the cached effect state never resets — and appends
the drained tail into the trailing pad the window already reserves.

Crucially this does NOT expand the Composer's requested range: doing so
pushes consecutive preview windows outside LimiterNode's 1-tick contiguity
tolerance and triggers a spurious Reset + double-processed overlap at every
chunk boundary (verified wrong in design review). Compensation is a node
contract instead, so exact window tiling and cached DSP state are preserved.

Scope: tail recovery only. Leading lookahead silence is left intact (removing
it would shift the clip and break A/V sync — documented-intended behavior).

Refs: Project #9 "AI Review" item "Audio graph: latency reporting/compensation API for lookahead-bearing AudioEffects"

Claude-Session: https://claude.ai/code/session_01PJ9eDL52jpiM1t5oDRCLM2

Addresses the CodeRabbit/Codex review of the Flush compensation: the default
Flush bypassed the node's own processing, hardcoded stereo, dropped fan-in
branches, and under-reported animated lookahead.

Unify everything on a ProcessTail(input, context) seam: Process feeds it real
upstream audio, Flush feeds it the drained tail, so a transforming node shapes
the tail exactly like the body. The base ProcessTail is pass-through, so the
zero-processing path stays byte-identical.

- AudioNode: default Flush now runs the upstream drain through ProcessTail
  (so a downstream Equalizer/Compressor/Gain processes the recovered tail);
  zero-input silence matches the last processed channel count instead of
  hardcoded stereo; a fan-in node without a Flush override now throws rather
  than silently dropping tails.
- Limiter/Gain/Equalizer/Compressor/Delay: Process bodies move into ProcessTail
  (LimiterNode's bespoke Flush is gone — it is now just a ProcessTail override).
- MixerNode: overrides Flush to drain and mix every branch, recovering a
  lookahead tail held in any fan-in branch.
- LimiterNode.GetLatencySamples: reports the worst-case lookahead when animated,
  so the drain reserves enough room when automation peaks near the clip end.
- SourceNode records its stereo output so the flush silence matches.

ClipNode's chunk-boundary-alignment tail loss (block ending exactly at the clip
end) is documented as a known limitation; the only fixes are out of scope (range
expansion resets the limiter; an oversized terminal buffer breaks the output
contract).

Refs: Project #9 "AI Review" item "Audio graph: latency reporting/compensation API for lookahead-bearing AudioEffects"

Claude-Session: https://claude.ai/code/session_01PJ9eDL52jpiM1t5oDRCLM2

The single-input Flush path disposed the drained buffer only after a
successful ProcessTail, leaking it on a throw. Wrap ProcessTail in try/catch
and dispose the drain on failure; Dispose is idempotent, so a transforming
node that already consumed the buffer is unaffected.

Addresses CodeRabbit review on PR #1998.

Claude-Session: https://claude.ai/code/session_01PJ9eDL52jpiM1t5oDRCLM2

LimiterNode reports the animated worst-case lookahead, but the effect-level
GetLatencySamples a host queries before graph construction still returned the
CurrentValue snapshot, so it could under-reserve and reintroduce the tail loss.
Mirror the node: an animated Lookahead reports MaxLookaheadMs.

Addresses Codex review on PR #1998.

Claude-Session: https://claude.ai/code/session_01PJ9eDL52jpiM1t5oDRCLM2

A SoundGroup mixes child clips and then flushes them through the group's
own clip in the group's time domain. A nested ClipNode inherited the base
single-input Flush, which forwarded the parent's drain context unchanged,
so the child's cached lookahead limiter saw a discontinuity, reset its
delay line, and dropped the very tail being drained.

Override ClipNode.Flush to rebuild the drain at clip-local Duration —
where the clip's last Process slice ended — mirroring AppendFlushedTail.
The parent's start is intentionally dropped, which is also why an
intervening ShiftNode needs no flush override of its own.

Document the remaining best-effort gaps (animated-lookahead drain,
custom-leaf channel count, DelayNode latency budget) inline as known
limitations / follow-ups rather than expanding the PR further.

ClipNode.Flush drained from the clip's natural Duration, which is wrong
when a parent (a SoundGroup window) trims the clip before its own end:
the cached effects last processed up to the trim boundary, so draining
from Duration skips past them, trips the limiter's discontinuity guard,
and drops the tail held at the boundary. Track the clip-local end of the
last processed window and drain from there instead.

Document the remaining best-effort gaps inline as known limitations:
MixerNode.Flush drains every branch unconditionally (a child that ended
early on the chunk-alignment edge can emit a stale tail late), and
SceneNode reports zero latency for a referenced scene (an inner limiter
tail is dropped at a SceneSound cut).

…de flush gap

Adds two Composer-level tests closing the coverage gap on AppendEndedSoundTails'
suppression branches: a non-contiguous (seek) window must not inject the previous
clip's stale limiter tail (IsContiguous early return), and InvalidateCache must
drop the recorded previous window so a subsequent contiguous window flushes nothing.
Both mirror Composer_FlushesSoundEndingExactlyAtTheWindowBoundary and assert silence
where that test asserts a recovered tail.

Also documents SpeedNode's missing Flush override (same class of limitation as
ResampleNode's, already documented there): a latency-bearing node placed upstream of
a SpeedNode would drop its tail on flush. Comment-only; no behavior change.